home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / dsp / dspgroup / macros.arc / UTILS.ASM < prev    next >
Encoding:
Assembly Source File  |  1983-11-17  |  21.7 KB  |  272 lines
  1.  
  2.       IDT 'SUBR'                                                                
  3. *                                                                               
  4. *  SUBROUTINES USED AS UTILITIES IN VARIOUS MACRO LANGUAGE EXTENSIONS AND       
  5. *  SIGNAL PROCESSING LANGUAGE MACROS.                                           
  6. *                                                                               
  7.       REF ONE,MINUS                                                             
  8.       REF XR0,XR1                                                               
  9. *                                                                               
  10. *  LDAC$ - LOAD THE ACCUMULATOR WITH VALUE FOUND IN PROGRAM MEMORY,             
  11. *          AT LOCATION POINTED TO BY ADDRESS ON THE TOP OF THE STACK.           
  12. *                                                                               
  13.       DEF LDAC$                                                                 
  14. LDAC$ POP                                                                       
  15.       TBLR XR0                                                                  
  16.       ADD  ONE                                                                  
  17.       PUSH                                                                      
  18.       LAC  XR0                                                                  
  19.       RET                                                                       
  20. *                                                                               
  21. *                                                                               
  22. *  RIP$ - SUBROUTINE USED FOR LOOPED VERSION OF RIPPLE MACRO                    
  23. *                                                                               
  24.       DEF RIP$                                                                  
  25. RIP$  POP                                                                       
  26.       TBLR XR0           * 1st argument = length                                
  27.       LAR  AR0,XR0       * R0 = count                                           
  28.       LARP AR0                                                                  
  29.       MAR  *-            * Decrement count                                      
  30.       SAR  AR0,XR0       * Store L-1 in XR0                                     
  31.       ADD  ONE           * Increment argument pointer                           
  32.       TBLR XR1           * 2nd argument = address                               
  33.       LAR  AR1,XR1       * Save address in R1                                   
  34.       SACL XR1           * Save argument pointer                                
  35.       LAC  XR0           * ACC = L-1                                            
  36.       SAR  AR1,XR0       * Get address from R1                                  
  37.       ADD  XR0           * ACC = address + L-1                                  
  38.       SACL XR0           * Save address                                         
  39.       LAR  AR1,XR0       * R1 = address pointer                                 
  40. RIP$L LARP AR1                                                                  
  41.       DMOV *-,AR0        * Shift data                                           
  42.       BANZ RIP$L                                                                
  43.       LAC  XR1           * Restore argument pointer                             
  44.       ADD  ONE           * Decrement argument pointer                           
  45.       PUSH               * Put return address on top of stack                   
  46.       RET                                                                       
  47. *                                                                               
  48. * LDAX$ - Load Accumulator with Double Word.                                    
  49. *                                                                               
  50.       DEF LDAX$                                                                 
  51. LDAX$ POP                * Get address of constants                             
  52.       TBLR XR1           * Read upper half                                      
  53.       ADD ONE                                                                   
  54.       TBLR XR0           * Read lower half                                      
  55.       ADD ONE                                                                   
  56.       PUSH                                                                      
  57.       ZALH XR1           * Load upper half                                      
  58.       ADDS XR0           * Load lower half                                      
  59.       RET                                                                       
  60. *                                                                               
  61. * LDAR$0 - Load Auxiliary Register 0 with word from program memory              
  62. *                                                                               
  63.        DEF LDAR$0                                                               
  64. LDAR$0 POP               * Get Address of Word                                  
  65.        TBLR XR0          * Read word into data memory                           
  66.        LAR  AR0,XR0      * Load into AR0                                        
  67.        ADD  ONE                                                                 
  68.        PUSH              * Restore return address                               
  69.        RET                                                                      
  70. *                                                                               
  71. * LDAR$1 - Load Auxiliary Register 1 with word from program memory              
  72. *                                                                               
  73.        DEF LDAR$1                                                               
  74. LDAR$1 POP               * Get Address of Word                                  
  75.        TBLR XR0          * Read word into data memory                           
  76.        LAR  AR1,XR0      * Load into AR1                                        
  77.        ADD  ONE                                                                 
  78.        PUSH              * Restore return address                               
  79.        RET                                                                      
  80. *                                                                               
  81. * LTK$  - Load T Register with word from program memory                         
  82. *                                                                               
  83.       DEF LTK$                                                                  
  84. LTK$  POP                * Get address of word                                  
  85.       TBLR XR0           * Read word into data memory                           
  86.       LT   XR0           * Load word into T register                            
  87.       ADD  ONE                                                                  
  88.       PUSH               * Restore return address                               
  89.       RET                                                                       
  90. *                                                                               
  91. * Instructions for MOVE macro.  There are four different entry positions,       
  92. * but all of them use code starting at MOV$M to do actual data transfer.        
  93. *                                                                               
  94. *                                                                               
  95. * MOVAB$  - MOVE A,B                                                            
  96. *                                                                               
  97. MOVAB$ POP                                                                      
  98.        TBLR XR0          * Read A into AR0                                      
  99.        LAR  AR0,XR0                                                             
  100.        ADD  ONE                                                                 
  101. MOVB$$ TBLR XR0          * Read B into AR1                                      
  102.        LAR  AR1,XR0                                                             
  103.        ADD  ONE                                                                 
  104.        B    MOV$M        * Move Data                                            
  105. *                                                                               
  106. * MOVA$  - MOVE A,*                                                             
  107. *                                                                               
  108. MOVA$  POP                                                                      
  109.        TBLR XR0          * Move A into AR0                                      
  110.        LAR  AR0,XR0                                                             
  111.        ADD  ONE                                                                 
  112.        B    MOV$M                                                               
  113. *                                                                               
  114. * MOVB$  - MOVE *,B                                                             
  115. *                                                                               
  116. MOVB$  POP                                                                      
  117.        B    MOVB$$       * Move B into AR1                                      
  118. *                                                                               
  119. * MOV$$  - MOVE *,*                                                             
  120. *                                                                               
  121. MOV$$  POP                                                                      
  122. MOV$M  TBLR XR0          * Read number of elements to move                      
  123.        SACL XR1          * Save Return Address                                  
  124.        LARP 0                                                                   
  125. MOV$L  LAC  *+,0,AR1     * Move @AR0 to ACC                                     
  126.        SACL *+,0,AR0     * Move ACC  to @AR1                                    
  127.        LAC  XR0                                                                 
  128.        SUB  ONE          * Decrement Loop Counter                               
  129.        SACL XR0                                                                 
  130.        BNZ  MOV$L        * Loop back for another move                           
  131.        LAC  XR1                                                                 
  132.        ADD  ONE                                                                 
  133.        PUSH              * Restore return address                               
  134.        RET                                                                      
  135.        DEF  MOVAB$,MOVA$,MOVB$,MOV$$                                            
  136. *                                                                               
  137. *   SETS$ - Move Constant into L postions of Data Memory                        
  138. *                                                                               
  139. SETS$ POP                                                                       
  140.       TBLR XR0           * Get 1st argument - constant                          
  141.       ADD  ONE                                                                  
  142.       TBLR XR1           * Get 2nd argument - count                             
  143.       LAR  AR0,XR1       * Use AR0 as counter                                   
  144.       LARP 0                                                                    
  145.       MAR  *-                                                                   
  146.       ADD  ONE                                                                  
  147.       TBLR XR1           * Get 3rd argument - destination                       
  148.       LAR  AR1,XR1       * Use AR1 as pointer                                   
  149.       SACL XR1           * Save Return Address                                  
  150.       LAC  XR0           * Load Constant into Accumulator                       
  151. SET$L LARP 1                                                                    
  152.       SACL *+,0,AR0      * Move Constant to data memory                         
  153.       BANZ SET$L         * Repeat L times                                       
  154.       LAC  XR1                                                                  
  155.       ADD  ONE                                                                  
  156.       PUSH               * Restore Return Address                               
  157.       RET                                                                       
  158.       DEF  SETS$                                                                
  159. *                                                                               
  160. *  MOVC$ AND MOVC$1 - Move List of Constants to Data Memory                     
  161. *                                                                               
  162. MOVC$  POP               * Get Argument Pointer                                 
  163.        TBLR XR0          * 1st Argument = Destination                           
  164.        LAR  AR1,XR0      * Use AR1 as pointer                                   
  165.        ADD  ONE          * Increment Arg pointer                                
  166.        B    MOVC$M                                                              
  167. MOVC$1 POP                                                                      
  168. MOVC$M TBLR XR0          * Read length of data                                  
  169.        LAR  AR0,XR0      * AR0 is loop counter                                  
  170.        LARP 0                                                                   
  171.        MAR  *-           * Decrement counter                                    
  172.        ADD  ONE          * Increment arg pointer                                
  173. MOVC$L LARP 1                                                                   
  174.        TBLR *+,AR0       * Read constant                                        
  175.        ADD  ONE                                                                 
  176.        BANZ MOVC$L       * Loop for length of data                              
  177.        PUSH              * Restore return address                               
  178.        RET                                                                      
  179.        DEF MOVC$,MOVC$1                                                         
  180. *                                                                               
  181. * Routines for MOVDAT macro                                                     
  182. *                                                                               
  183. * MOVA$B -  MOVDAT A,B,L                                                        
  184. *                                                                               
  185. MOVA$B POP                                                                      
  186.        TBLR XR0          * 1st Argument is source                               
  187.        LAR  AR0,XR0                                                             
  188.        ADD  ONE          * Increment pointer                                    
  189. MOVCB$ TBLR XR0          * Next Argument is destination                         
  190.        LAR  AR1,XR0                                                             
  191.        ADD  ONE          * Increment pointer                                    
  192.        B    MOV$$M                                                              
  193. *                                                                               
  194. * MOVC$A -  MOVDAT A,*,L or MOVDAT A,,L                                         
  195. *                                                                               
  196. MOVC$A POP                                                                      
  197.        TBLR XR0          * Read Source Argument                                 
  198.        LAR  AR0,XR0                                                             
  199.        ADD  ONE          * Increment Pointer                                    
  200.        B    MOV$$M                                                              
  201. *                                                                               
  202. * MOVC$B -  MOVDAT *,B,L or MOVDAT ,B,L                                         
  203. *                                                                               
  204. MOVC$B POP                                                                      
  205.        B    MOVCB$       * Get Destination Argument                             
  206. *                                                                               
  207. * MOVC$$ - MOVDAT ,*,L or MOVDAT *,,L or MOVDAT *,*,L                           
  208. *                                                                               
  209. MOVC$$ POP                                                                      
  210. MOV$$M SAR  AR0,XR0      * Save Source Location                                 
  211.        TBLR XR1          * Read Length                                          
  212.        LAR  AR0,XR1                                                             
  213.        LARP 0                                                                   
  214.        MAR  *-           * Decrement Count                                      
  215.        SACL XR1          * Save Return Address                                  
  216.        LAC  XR0          * Load Start Address                                   
  217. MOV$$L LARP 1                                                                   
  218.        TBLR *+,AR0       * Move to Data Memory                                  
  219.        ADD  ONE          * Update Source Pointer                                
  220.        BANZ MOV$$L       * Loop on Array Length                                 
  221.        LAC  XR1                                                                 
  222.        ADD  ONE                                                                 
  223.        PUSH              * Restore Return Address                               
  224.        RET                                                                      
  225.        DEF MOVA$B,MOVC$A,MOVC$B,MOVC$$                                          
  226. *                                                                               
  227. *  MOVROM routines                                                              
  228. *                                                                               
  229. *  TBW$$ - MOVROM A,B,L                                                         
  230. *                                                                               
  231. TBW$$  POP                                                                      
  232.        TBLR XR0          * Read Source Address                                  
  233.        LAR  AR0,XR0                                                             
  234.        ADD  ONE          * Update Pointer                                       
  235. TBW0$  TBLR XR0          * Read Destination Address                             
  236.        LAR  AR1,XR0                                                             
  237.        ADD  ONE          * Update Pointer                                       
  238.        B    TBW$M                                                               
  239. *                                                                               
  240. *  TBW$1 - MOVROM A,*,L or MOVROM A,,L                                          
  241. *                                                                               
  242. TBW$1  POP                                                                      
  243.        TBLR XR0          * Read Source Address                                  
  244.        LAR  AR0,XR0                                                             
  245.        ADD  ONE          * Update Pointer                                       
  246.        B    TBW$M                                                               
  247. *                                                                               
  248. *  TBW$0 -  MOVROM *,B,L or MOVROM ,B,L                                         
  249. *                                                                               
  250. TBW$0  POP                                                                      
  251.        B    TBW0$        * Read Destination Address                             
  252. *                                                                               
  253. *  TBW$$ -  MOVROM *,*,L or MOVROM *,,L or MOVROM ,*,L                          
  254. *                                                                               
  255. TBW$01 POP                                                                      
  256. TBW$M  SAR  AR1,XR0      * Save Destination Address                             
  257.        TBLR XR1          * Read Length of Move                                  
  258.        LAR  AR1,XR1                                                             
  259.        LARP 1                                                                   
  260.        MAR  *-           * Decrement Counter                                    
  261.        SACL XR1          * Save Return Address                                  
  262.        LAC  XR0          * Load Destination Address                             
  263. TBW$L  LARP 0                                                                   
  264.        TBLW *+,AR1       * Move Data                                            
  265.        ADD  ONE          * Increment Pointer                                    
  266.        BANZ TBW$L        * Loop on Length                                       
  267.        LAC  XR1                                                                 
  268.        ADD  ONE                                                                 
  269.        PUSH              * Restore Return Address                               
  270.        RET                                                                      
  271.        DEF  TBW$$,TBW$1,TBW$0,TBW$01                                            
  272.        END